#ifndef PROPERTY_BAG_H_
#define PROPERTY_BAG_H_

#include <any>
#include <cstdint>
#include <string>
#include <typeindex>
#include <typeinfo>
#include <unordered_map>
#include <vector>


class PropertyBag {
public:
    /*====================  设置 ====================*/
    template <typename T>
    PropertyBag& set(const std::string& key, const T& value) {
        data_[key] = value;
        return *this;
    }

    /*====================  取值代理 ====================*/
    class Proxy {
    public:
        // 构造：包内指针，可能为 nullptr
        explicit Proxy(std::any* ptr) : ptr_(ptr) {}

        /*-------- 各种带默认值的 toXxx() --------*/
        PropertyBag toObject() const {
            if (!ptr_)
                return {};
            try {
                return std::any_cast<PropertyBag>(*ptr_);
            } catch (const std::bad_any_cast&) {
                return {};  // 类型不匹配返回空 PropertyBag
            }
        }
        template <typename T>
        T to(T default_val = T()) const {
            return cast<T>(default_val);
        }
        int toInt(int default_val = 0) const { return cast<int>(default_val); }
        bool toBool(bool default_val = false) const {
            return cast<bool>(default_val);
        }
        double toDouble(double default_val = 0.0) const {
            return cast<double>(default_val);
        }
        std::string toString(const std::string& default_val = "") const {
            return cast<std::string>(default_val);
        }
        template <typename T>
        std::vector<T> toVec(const std::vector<T>& default_val = {}) const {
            return cast<std::vector<T>>(default_val);
        }

        bool isValid() const { return ptr_ && ptr_->has_value(); }

        /*-------- 关键：支持 = 操作符，完成赋值 --------*/
        template <typename T>
        const T& operator=(const T& value) const {
            if (ptr_)
                *ptr_ = value;
            return value;
        }

    private:
        std::any* ptr_;

        template <typename T>
        T cast(const T& default_val) const {
            if (!ptr_)
                return default_val;
            try {
                return std::any_cast<T>(*ptr_);
            } catch (const std::bad_any_cast&) {
                return default_val;
            }
        }
    };

    /*====================  重载中括号 ====================*/
    Proxy operator[](const std::string& key) {
        return Proxy(&data_[key]);  // 不存在会默认插入空的 any
    }

    Proxy operator[](const std::string& key) const {
        auto it = data_.find(key);
        if (it == data_.end()) {
            static std::any null_any;
            return Proxy(const_cast<std::any*>(&null_any));
        }
        return Proxy(const_cast<std::any*>(&it->second));
    }

    /*====================  其余 ====================*/
    bool remove(const std::string& key) { return data_.erase(key) > 0; }
    void clear() { data_.clear(); }
    bool contains(const std::string& key) const { return data_.count(key); }
    std::size_t size() const { return data_.size(); }

private:
    mutable std::unordered_map<std::string, std::any> data_;
};

#endif  // PROPERTY_BAG_H_